package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade ENSAIO_BANCADA
 * @author Gerado pelo Telescope
 */
public class EntEnsaioBancada extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.ENSAIO_BANCADA";
    public final static String TABLE_NAME = "ENSAIO_BANCADA";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntEnsaioBancada() {
        super();
        initialize();
    }
    
    public EntEnsaioBancada(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aSituacaoEnsaioHidrostatico = new DomOption(this,"SITUACAO_ENSAIO_HIDROSTATICO", "Situação do ensaio hidrostático"); 
        aSituacaoEnsaioHidrostatico.setRequired(true);
        aSituacaoEnsaioHidrostatico.setSize(1);
        aSituacaoEnsaioHidrostatico.clearOptions();
        aSituacaoEnsaioHidrostatico.addOption("A", "Aprovado");
        aSituacaoEnsaioHidrostatico.addOption("Z", "A realizar");
        aSituacaoEnsaioHidrostatico.addOption("R", "Reprovado");
        aSituacaoEnsaioHidrostatico.setDefaultValue("Z");
        oSituacaoEnsaioHidrostatico = new DomOption();
        aSituacaoEnsaioVisual = new DomOption(this,"SITUACAO_ENSAIO_VISUAL", "Situação do ensaio visual"); 
        aSituacaoEnsaioVisual.setRequired(true);
        aSituacaoEnsaioVisual.setSize(1);
        aSituacaoEnsaioVisual.clearOptions();
        aSituacaoEnsaioVisual.addOption("A", "Aprovado");
        aSituacaoEnsaioVisual.addOption("Z", "A realizar");
        aSituacaoEnsaioVisual.addOption("R", "Reprovado");
        aSituacaoEnsaioVisual.setDefaultValue("Z");
        oSituacaoEnsaioVisual = new DomOption();
        aDataInicioEnsaio = new DomDate(this,"DATA_INICIO_ENSAIO", "Data de início do ensaio"); 
        oDataInicioEnsaio = new DomDate();
        aDataFimEnsaio = new DomDate(this,"DATA_FIM_ENSAIO", "Data do fim do ensaio"); 
        oDataFimEnsaio = new DomDate();
        aHoraInicioEnsaio = new DomTime(this,"HORA_INICIO_ENSAIO", "Hora do início do ensaio"); 
        oHoraInicioEnsaio = new DomTime();
        aHoraFimEnsaio = new DomTime(this,"HORA_FIM_ENSAIO", "Hora do fim do ensaio"); 
        oHoraFimEnsaio = new DomTime();
        aSolicitacaoEnsaioId = new DomId(this,"SOLICITACAO_ENSAIO_ID", "Solicitação do ensaio"); 
        oSolicitacaoEnsaioId = new DomId();
        aBancadaEnsaioId = new DomId(this,"BANCADA_ENSAIO_ID", "Bancada do ensaio"); 
        aBancadaEnsaioId.setRequired(true);
        oBancadaEnsaioId = new DomId();
        aQuantidadeHidrometros = new DomInteger(this,"QUANTIDADE_HIDROMETROS", "Quantidade de hidrômetros"); 
        aQuantidadeHidrometros.setRequired(true);
        oQuantidadeHidrometros = new DomInteger();
        aNumeroLaudo = new DomText(this,"NUMERO_LAUDO", "Número do laudo"); 
        oNumeroLaudo = new DomText();
        aOperadorEnsaioId = new DomId(this,"OPERADOR_ENSAIO_ID", "Operador do ensaio"); 
        aOperadorEnsaioId.setRequired(true);
        oOperadorEnsaioId = new DomId();
        aSituacao = new DomOption(this,"SITUACAO", "Situação da execução"); 
        aSituacao.setRequired(true);
        aSituacao.setSize(1);
        aSituacao.clearOptions();
        aSituacao.addOption("C", "Cancelado");
        aSituacao.addOption("E", "Em execução");
        aSituacao.addOption("X", "Executado");
        aSituacao.addOption("F", "Finalizado");
        aSituacao.addOption("P", "Pendente");
        aSituacao.setDefaultValue("P");
        oSituacao = new DomOption();
        aSequenciaAutomatica = new DomId(this,"SEQUENCIA_AUTOMATICA", "Sequência automatica"); 
        aSequenciaAutomatica.setRequired(true);
        oSequenciaAutomatica = new DomId();
        aQuantidadeHidrometrosAprovados = new DomInteger(this,"QUANTIDADE_HIDROMETROS_APROVADOS", "Quantidade de hidrômetros aprovados"); 
        aQuantidadeHidrometrosAprovados.setRequired(true);
        aQuantidadeHidrometrosAprovados.setDefaultValue("0");
        oQuantidadeHidrometrosAprovados = new DomInteger();
        aQuantidadeHidrometrosReprovados = new DomInteger(this,"QUANTIDADE_HIDROMETROS_REPROVADOS", "Quantidade de hidrômetros reprovados"); 
        aQuantidadeHidrometrosReprovados.setRequired(true);
        aQuantidadeHidrometrosReprovados.setDefaultValue("0");
        oQuantidadeHidrometrosReprovados = new DomInteger();
        aPlanoExecucaoId = new DomId(this,"PLANO_EXECUCAO_ID", "Plano de execução"); 
        aPlanoExecucaoId.setRequired(true);
        oPlanoExecucaoId = new DomId();
        aModeloHidrometroId = new DomId(this,"MODELO_HIDROMETRO_ID", "Modelo de hidrômetro"); 
        aModeloHidrometroId.setRequired(true);
        oModeloHidrometroId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Situação do ensaio hidrostático
    private DomOption aSituacaoEnsaioHidrostatico;
    private DomOption oSituacaoEnsaioHidrostatico;
    
    // Situação do ensaio visual
    private DomOption aSituacaoEnsaioVisual;
    private DomOption oSituacaoEnsaioVisual;
    
    // Data de início do ensaio
    private DomDate aDataInicioEnsaio;
    private DomDate oDataInicioEnsaio;
    
    // Data do fim do ensaio
    private DomDate aDataFimEnsaio;
    private DomDate oDataFimEnsaio;
    
    // Hora do início do ensaio
    private DomTime aHoraInicioEnsaio;
    private DomTime oHoraInicioEnsaio;
    
    // Hora do fim do ensaio
    private DomTime aHoraFimEnsaio;
    private DomTime oHoraFimEnsaio;
    
    // Solicitação do ensaio
    private DomId aSolicitacaoEnsaioId;
    private DomId oSolicitacaoEnsaioId;
    
    // Bancada do ensaio
    private DomId aBancadaEnsaioId;
    private DomId oBancadaEnsaioId;
    
    // Quantidade de hidrômetros
    private DomInteger aQuantidadeHidrometros;
    private DomInteger oQuantidadeHidrometros;
    
    // Número do laudo
    private DomText aNumeroLaudo;
    private DomText oNumeroLaudo;
    
    // Operador do ensaio
    private DomId aOperadorEnsaioId;
    private DomId oOperadorEnsaioId;
    
    // Situação da execução
    private DomOption aSituacao;
    private DomOption oSituacao;
    
    // Sequência automatica
    private DomId aSequenciaAutomatica;
    private DomId oSequenciaAutomatica;
    
    // Quantidade de hidrômetros aprovados
    private DomInteger aQuantidadeHidrometrosAprovados;
    private DomInteger oQuantidadeHidrometrosAprovados;
    
    // Quantidade de hidrômetros reprovados
    private DomInteger aQuantidadeHidrometrosReprovados;
    private DomInteger oQuantidadeHidrometrosReprovados;
    
    // Plano de execução
    private DomId aPlanoExecucaoId;
    private DomId oPlanoExecucaoId;
    
    // Modelo de hidrômetro
    private DomId aModeloHidrometroId;
    private DomId oModeloHidrometroId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntEnsaioBancada id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO_ENSAIO_HIDROSTATICO">
    
    public EntEnsaioBancada situacaoEnsaioHidrostatico(String value) {
        setSituacaoEnsaioHidrostatico(value);
        return this;
    }
    
    public void setSituacaoEnsaioHidrostatico(DomOption value) {
        if (value == null || value.isNull()) {
            nullifySituacaoEnsaioHidrostatico();
        } else {
            aSituacaoEnsaioHidrostatico.setValue(value.getValue());
            if (aSituacaoEnsaioHidrostatico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacaoEnsaioHidrostatico(String value) {
        if (value == null) {
            nullifySituacaoEnsaioHidrostatico();
        } else {
            aSituacaoEnsaioHidrostatico.setValue(value);
            if (aSituacaoEnsaioHidrostatico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacaoEnsaioHidrostatico(Object value) {
        aSituacaoEnsaioHidrostatico.setValue(value);
        if (aSituacaoEnsaioHidrostatico.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacaoEnsaioHidrostatico() {
        if (!aSituacaoEnsaioHidrostatico.isNull()) {
            aSituacaoEnsaioHidrostatico.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getSituacaoEnsaioHidrostatico() {
        return aSituacaoEnsaioHidrostatico;
    }
    
    public DomOption oldSituacaoEnsaioHidrostatico() {
        return oSituacaoEnsaioHidrostatico;
    }
    
    public String valueOfSituacaoEnsaioHidrostatico() {
        return aSituacaoEnsaioHidrostatico.getValue();
    }
    
    public boolean isSituacaoEnsaioHidrostaticoModified() {
        return aSituacaoEnsaioHidrostatico.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO_ENSAIO_VISUAL">
    
    public EntEnsaioBancada situacaoEnsaioVisual(String value) {
        setSituacaoEnsaioVisual(value);
        return this;
    }
    
    public void setSituacaoEnsaioVisual(DomOption value) {
        if (value == null || value.isNull()) {
            nullifySituacaoEnsaioVisual();
        } else {
            aSituacaoEnsaioVisual.setValue(value.getValue());
            if (aSituacaoEnsaioVisual.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacaoEnsaioVisual(String value) {
        if (value == null) {
            nullifySituacaoEnsaioVisual();
        } else {
            aSituacaoEnsaioVisual.setValue(value);
            if (aSituacaoEnsaioVisual.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacaoEnsaioVisual(Object value) {
        aSituacaoEnsaioVisual.setValue(value);
        if (aSituacaoEnsaioVisual.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacaoEnsaioVisual() {
        if (!aSituacaoEnsaioVisual.isNull()) {
            aSituacaoEnsaioVisual.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getSituacaoEnsaioVisual() {
        return aSituacaoEnsaioVisual;
    }
    
    public DomOption oldSituacaoEnsaioVisual() {
        return oSituacaoEnsaioVisual;
    }
    
    public String valueOfSituacaoEnsaioVisual() {
        return aSituacaoEnsaioVisual.getValue();
    }
    
    public boolean isSituacaoEnsaioVisualModified() {
        return aSituacaoEnsaioVisual.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_INICIO_ENSAIO">
    
    public EntEnsaioBancada dataInicioEnsaio(java.sql.Date value) {
        setDataInicioEnsaio(value);
        return this;
    }
    
    public void setDataInicioEnsaio(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataInicioEnsaio();
        } else {
            aDataInicioEnsaio.setValue(value.getValue());
            if (aDataInicioEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataInicioEnsaio(String value) {
        if (value == null) {
            nullifyDataInicioEnsaio();
        } else {
            aDataInicioEnsaio.setValue(value);
            if (aDataInicioEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataInicioEnsaio(java.sql.Date value) {
        aDataInicioEnsaio.setValue(value);
        if (aDataInicioEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataInicioEnsaio(Object value) {
        aDataInicioEnsaio.setValue(value);
        if (aDataInicioEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataInicioEnsaio() {
        if (!aDataInicioEnsaio.isNull()) {
            aDataInicioEnsaio.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataInicioEnsaio() {
        return aDataInicioEnsaio;
    }
    
    public DomDate oldDataInicioEnsaio() {
        return oDataInicioEnsaio;
    }
    
    public java.sql.Date valueOfDataInicioEnsaio() {
        return aDataInicioEnsaio.getValue();
    }
    
    public boolean isDataInicioEnsaioModified() {
        return aDataInicioEnsaio.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_FIM_ENSAIO">
    
    public EntEnsaioBancada dataFimEnsaio(java.sql.Date value) {
        setDataFimEnsaio(value);
        return this;
    }
    
    public void setDataFimEnsaio(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataFimEnsaio();
        } else {
            aDataFimEnsaio.setValue(value.getValue());
            if (aDataFimEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataFimEnsaio(String value) {
        if (value == null) {
            nullifyDataFimEnsaio();
        } else {
            aDataFimEnsaio.setValue(value);
            if (aDataFimEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataFimEnsaio(java.sql.Date value) {
        aDataFimEnsaio.setValue(value);
        if (aDataFimEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataFimEnsaio(Object value) {
        aDataFimEnsaio.setValue(value);
        if (aDataFimEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataFimEnsaio() {
        if (!aDataFimEnsaio.isNull()) {
            aDataFimEnsaio.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataFimEnsaio() {
        return aDataFimEnsaio;
    }
    
    public DomDate oldDataFimEnsaio() {
        return oDataFimEnsaio;
    }
    
    public java.sql.Date valueOfDataFimEnsaio() {
        return aDataFimEnsaio.getValue();
    }
    
    public boolean isDataFimEnsaioModified() {
        return aDataFimEnsaio.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo HORA_INICIO_ENSAIO">
    
    public EntEnsaioBancada horaInicioEnsaio(java.sql.Time value) {
        setHoraInicioEnsaio(value);
        return this;
    }
    
    public void setHoraInicioEnsaio(DomTime value) {
        if (value == null || value.isNull()) {
            nullifyHoraInicioEnsaio();
        } else {
            aHoraInicioEnsaio.setValue(value.getValue());
            if (aHoraInicioEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setHoraInicioEnsaio(String value) {
        if (value == null) {
            nullifyHoraInicioEnsaio();
        } else {
            aHoraInicioEnsaio.setValue(value);
            if (aHoraInicioEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setHoraInicioEnsaio(java.sql.Time value) {
        aHoraInicioEnsaio.setValue(value);
        if (aHoraInicioEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void setHoraInicioEnsaio(Object value) {
        aHoraInicioEnsaio.setValue(value);
        if (aHoraInicioEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyHoraInicioEnsaio() {
        if (!aHoraInicioEnsaio.isNull()) {
            aHoraInicioEnsaio.setNull(true);
            setModified(true);
        }
    }
    
    public DomTime getHoraInicioEnsaio() {
        return aHoraInicioEnsaio;
    }
    
    public DomTime oldHoraInicioEnsaio() {
        return oHoraInicioEnsaio;
    }
    
    public java.sql.Time valueOfHoraInicioEnsaio() {
        return aHoraInicioEnsaio.getValue();
    }
    
    public boolean isHoraInicioEnsaioModified() {
        return aHoraInicioEnsaio.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo HORA_FIM_ENSAIO">
    
    public EntEnsaioBancada horaFimEnsaio(java.sql.Time value) {
        setHoraFimEnsaio(value);
        return this;
    }
    
    public void setHoraFimEnsaio(DomTime value) {
        if (value == null || value.isNull()) {
            nullifyHoraFimEnsaio();
        } else {
            aHoraFimEnsaio.setValue(value.getValue());
            if (aHoraFimEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setHoraFimEnsaio(String value) {
        if (value == null) {
            nullifyHoraFimEnsaio();
        } else {
            aHoraFimEnsaio.setValue(value);
            if (aHoraFimEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setHoraFimEnsaio(java.sql.Time value) {
        aHoraFimEnsaio.setValue(value);
        if (aHoraFimEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void setHoraFimEnsaio(Object value) {
        aHoraFimEnsaio.setValue(value);
        if (aHoraFimEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyHoraFimEnsaio() {
        if (!aHoraFimEnsaio.isNull()) {
            aHoraFimEnsaio.setNull(true);
            setModified(true);
        }
    }
    
    public DomTime getHoraFimEnsaio() {
        return aHoraFimEnsaio;
    }
    
    public DomTime oldHoraFimEnsaio() {
        return oHoraFimEnsaio;
    }
    
    public java.sql.Time valueOfHoraFimEnsaio() {
        return aHoraFimEnsaio.getValue();
    }
    
    public boolean isHoraFimEnsaioModified() {
        return aHoraFimEnsaio.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SOLICITACAO_ENSAIO_ID">
    
    public EntEnsaioBancada solicitacaoEnsaioId(Long value) {
        setSolicitacaoEnsaioId(value);
        return this;
    }
    
    public void setSolicitacaoEnsaioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifySolicitacaoEnsaioId();
        } else {
            aSolicitacaoEnsaioId.setValue(value.getValue());
            if (aSolicitacaoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSolicitacaoEnsaioId(String value) {
        if (value == null) {
            nullifySolicitacaoEnsaioId();
        } else {
            aSolicitacaoEnsaioId.setValue(value);
            if (aSolicitacaoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSolicitacaoEnsaioId(Long value) {
        aSolicitacaoEnsaioId.setValue(value);
        if (aSolicitacaoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setSolicitacaoEnsaioId(Object value) {
        aSolicitacaoEnsaioId.setValue(value);
        if (aSolicitacaoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySolicitacaoEnsaioId() {
        if (!aSolicitacaoEnsaioId.isNull()) {
            aSolicitacaoEnsaioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getSolicitacaoEnsaioId() {
        return aSolicitacaoEnsaioId;
    }
    
    public DomId oldSolicitacaoEnsaioId() {
        return oSolicitacaoEnsaioId;
    }
    
    public Long valueOfSolicitacaoEnsaioId() {
        return aSolicitacaoEnsaioId.getValue();
    }
    
    public boolean isSolicitacaoEnsaioIdModified() {
        return aSolicitacaoEnsaioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo BANCADA_ENSAIO_ID">
    
    public EntEnsaioBancada bancadaEnsaioId(Long value) {
        setBancadaEnsaioId(value);
        return this;
    }
    
    public void setBancadaEnsaioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyBancadaEnsaioId();
        } else {
            aBancadaEnsaioId.setValue(value.getValue());
            if (aBancadaEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setBancadaEnsaioId(String value) {
        if (value == null) {
            nullifyBancadaEnsaioId();
        } else {
            aBancadaEnsaioId.setValue(value);
            if (aBancadaEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setBancadaEnsaioId(Long value) {
        aBancadaEnsaioId.setValue(value);
        if (aBancadaEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setBancadaEnsaioId(Object value) {
        aBancadaEnsaioId.setValue(value);
        if (aBancadaEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyBancadaEnsaioId() {
        if (!aBancadaEnsaioId.isNull()) {
            aBancadaEnsaioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getBancadaEnsaioId() {
        return aBancadaEnsaioId;
    }
    
    public DomId oldBancadaEnsaioId() {
        return oBancadaEnsaioId;
    }
    
    public Long valueOfBancadaEnsaioId() {
        return aBancadaEnsaioId.getValue();
    }
    
    public boolean isBancadaEnsaioIdModified() {
        return aBancadaEnsaioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS">
    
    public EntEnsaioBancada quantidadeHidrometros(Integer value) {
        setQuantidadeHidrometros(value);
        return this;
    }
    
    public void setQuantidadeHidrometros(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometros();
        } else {
            aQuantidadeHidrometros.setValue(value.getValue());
            if (aQuantidadeHidrometros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometros(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometros();
        } else {
            aQuantidadeHidrometros.setValue(value);
            if (aQuantidadeHidrometros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometros(Integer value) {
        aQuantidadeHidrometros.setValue(value);
        if (aQuantidadeHidrometros.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometros(Object value) {
        aQuantidadeHidrometros.setValue(value);
        if (aQuantidadeHidrometros.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometros() {
        if (!aQuantidadeHidrometros.isNull()) {
            aQuantidadeHidrometros.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometros() {
        return aQuantidadeHidrometros;
    }
    
    public DomInteger oldQuantidadeHidrometros() {
        return oQuantidadeHidrometros;
    }
    
    public Integer valueOfQuantidadeHidrometros() {
        return aQuantidadeHidrometros.getValue();
    }
    
    public boolean isQuantidadeHidrometrosModified() {
        return aQuantidadeHidrometros.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NUMERO_LAUDO">
    
    public EntEnsaioBancada numeroLaudo(String value) {
        setNumeroLaudo(value);
        return this;
    }
    
    public void setNumeroLaudo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyNumeroLaudo();
        } else {
            aNumeroLaudo.setValue(value.getValue());
            if (aNumeroLaudo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroLaudo(String value) {
        if (value == null) {
            nullifyNumeroLaudo();
        } else {
            aNumeroLaudo.setValue(value);
            if (aNumeroLaudo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroLaudo(Object value) {
        aNumeroLaudo.setValue(value);
        if (aNumeroLaudo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNumeroLaudo() {
        if (!aNumeroLaudo.isNull()) {
            aNumeroLaudo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getNumeroLaudo() {
        return aNumeroLaudo;
    }
    
    public DomText oldNumeroLaudo() {
        return oNumeroLaudo;
    }
    
    public String valueOfNumeroLaudo() {
        return aNumeroLaudo.getValue();
    }
    
    public boolean isNumeroLaudoModified() {
        return aNumeroLaudo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo OPERADOR_ENSAIO_ID">
    
    public EntEnsaioBancada operadorEnsaioId(Long value) {
        setOperadorEnsaioId(value);
        return this;
    }
    
    public void setOperadorEnsaioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyOperadorEnsaioId();
        } else {
            aOperadorEnsaioId.setValue(value.getValue());
            if (aOperadorEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOperadorEnsaioId(String value) {
        if (value == null) {
            nullifyOperadorEnsaioId();
        } else {
            aOperadorEnsaioId.setValue(value);
            if (aOperadorEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOperadorEnsaioId(Long value) {
        aOperadorEnsaioId.setValue(value);
        if (aOperadorEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setOperadorEnsaioId(Object value) {
        aOperadorEnsaioId.setValue(value);
        if (aOperadorEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOperadorEnsaioId() {
        if (!aOperadorEnsaioId.isNull()) {
            aOperadorEnsaioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getOperadorEnsaioId() {
        return aOperadorEnsaioId;
    }
    
    public DomId oldOperadorEnsaioId() {
        return oOperadorEnsaioId;
    }
    
    public Long valueOfOperadorEnsaioId() {
        return aOperadorEnsaioId.getValue();
    }
    
    public boolean isOperadorEnsaioIdModified() {
        return aOperadorEnsaioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO">
    
    public EntEnsaioBancada situacao(String value) {
        setSituacao(value);
        return this;
    }
    
    public void setSituacao(DomOption value) {
        if (value == null || value.isNull()) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value.getValue());
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(String value) {
        if (value == null) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value);
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(Object value) {
        aSituacao.setValue(value);
        if (aSituacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacao() {
        if (!aSituacao.isNull()) {
            aSituacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getSituacao() {
        return aSituacao;
    }
    
    public DomOption oldSituacao() {
        return oSituacao;
    }
    
    public String valueOfSituacao() {
        return aSituacao.getValue();
    }
    
    public boolean isSituacaoModified() {
        return aSituacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA_AUTOMATICA">
    
    public EntEnsaioBancada sequenciaAutomatica(Long value) {
        setSequenciaAutomatica(value);
        return this;
    }
    
    public void setSequenciaAutomatica(DomId value) {
        if (value == null || value.isNull()) {
            nullifySequenciaAutomatica();
        } else {
            aSequenciaAutomatica.setValue(value.getValue());
            if (aSequenciaAutomatica.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaAutomatica(String value) {
        if (value == null) {
            nullifySequenciaAutomatica();
        } else {
            aSequenciaAutomatica.setValue(value);
            if (aSequenciaAutomatica.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaAutomatica(Long value) {
        aSequenciaAutomatica.setValue(value);
        if (aSequenciaAutomatica.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequenciaAutomatica(Object value) {
        aSequenciaAutomatica.setValue(value);
        if (aSequenciaAutomatica.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequenciaAutomatica() {
        if (!aSequenciaAutomatica.isNull()) {
            aSequenciaAutomatica.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getSequenciaAutomatica() {
        return aSequenciaAutomatica;
    }
    
    public DomId oldSequenciaAutomatica() {
        return oSequenciaAutomatica;
    }
    
    public Long valueOfSequenciaAutomatica() {
        return aSequenciaAutomatica.getValue();
    }
    
    public boolean isSequenciaAutomaticaModified() {
        return aSequenciaAutomatica.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS_APROVADOS">
    
    public EntEnsaioBancada quantidadeHidrometrosAprovados(Integer value) {
        setQuantidadeHidrometrosAprovados(value);
        return this;
    }
    
    public void setQuantidadeHidrometrosAprovados(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometrosAprovados();
        } else {
            aQuantidadeHidrometrosAprovados.setValue(value.getValue());
            if (aQuantidadeHidrometrosAprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosAprovados(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometrosAprovados();
        } else {
            aQuantidadeHidrometrosAprovados.setValue(value);
            if (aQuantidadeHidrometrosAprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosAprovados(Integer value) {
        aQuantidadeHidrometrosAprovados.setValue(value);
        if (aQuantidadeHidrometrosAprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometrosAprovados(Object value) {
        aQuantidadeHidrometrosAprovados.setValue(value);
        if (aQuantidadeHidrometrosAprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometrosAprovados() {
        if (!aQuantidadeHidrometrosAprovados.isNull()) {
            aQuantidadeHidrometrosAprovados.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometrosAprovados() {
        return aQuantidadeHidrometrosAprovados;
    }
    
    public DomInteger oldQuantidadeHidrometrosAprovados() {
        return oQuantidadeHidrometrosAprovados;
    }
    
    public Integer valueOfQuantidadeHidrometrosAprovados() {
        return aQuantidadeHidrometrosAprovados.getValue();
    }
    
    public boolean isQuantidadeHidrometrosAprovadosModified() {
        return aQuantidadeHidrometrosAprovados.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS_REPROVADOS">
    
    public EntEnsaioBancada quantidadeHidrometrosReprovados(Integer value) {
        setQuantidadeHidrometrosReprovados(value);
        return this;
    }
    
    public void setQuantidadeHidrometrosReprovados(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometrosReprovados();
        } else {
            aQuantidadeHidrometrosReprovados.setValue(value.getValue());
            if (aQuantidadeHidrometrosReprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosReprovados(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometrosReprovados();
        } else {
            aQuantidadeHidrometrosReprovados.setValue(value);
            if (aQuantidadeHidrometrosReprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosReprovados(Integer value) {
        aQuantidadeHidrometrosReprovados.setValue(value);
        if (aQuantidadeHidrometrosReprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometrosReprovados(Object value) {
        aQuantidadeHidrometrosReprovados.setValue(value);
        if (aQuantidadeHidrometrosReprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometrosReprovados() {
        if (!aQuantidadeHidrometrosReprovados.isNull()) {
            aQuantidadeHidrometrosReprovados.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometrosReprovados() {
        return aQuantidadeHidrometrosReprovados;
    }
    
    public DomInteger oldQuantidadeHidrometrosReprovados() {
        return oQuantidadeHidrometrosReprovados;
    }
    
    public Integer valueOfQuantidadeHidrometrosReprovados() {
        return aQuantidadeHidrometrosReprovados.getValue();
    }
    
    public boolean isQuantidadeHidrometrosReprovadosModified() {
        return aQuantidadeHidrometrosReprovados.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PLANO_EXECUCAO_ID">
    
    public EntEnsaioBancada planoExecucaoId(Long value) {
        setPlanoExecucaoId(value);
        return this;
    }
    
    public void setPlanoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value.getValue());
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(String value) {
        if (value == null) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value);
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(Long value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPlanoExecucaoId(Object value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPlanoExecucaoId() {
        if (!aPlanoExecucaoId.isNull()) {
            aPlanoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPlanoExecucaoId() {
        return aPlanoExecucaoId;
    }
    
    public DomId oldPlanoExecucaoId() {
        return oPlanoExecucaoId;
    }
    
    public Long valueOfPlanoExecucaoId() {
        return aPlanoExecucaoId.getValue();
    }
    
    public boolean isPlanoExecucaoIdModified() {
        return aPlanoExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MODELO_HIDROMETRO_ID">
    
    public EntEnsaioBancada modeloHidrometroId(Long value) {
        setModeloHidrometroId(value);
        return this;
    }
    
    public void setModeloHidrometroId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyModeloHidrometroId();
        } else {
            aModeloHidrometroId.setValue(value.getValue());
            if (aModeloHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setModeloHidrometroId(String value) {
        if (value == null) {
            nullifyModeloHidrometroId();
        } else {
            aModeloHidrometroId.setValue(value);
            if (aModeloHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setModeloHidrometroId(Long value) {
        aModeloHidrometroId.setValue(value);
        if (aModeloHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void setModeloHidrometroId(Object value) {
        aModeloHidrometroId.setValue(value);
        if (aModeloHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyModeloHidrometroId() {
        if (!aModeloHidrometroId.isNull()) {
            aModeloHidrometroId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getModeloHidrometroId() {
        return aModeloHidrometroId;
    }
    
    public DomId oldModeloHidrometroId() {
        return oModeloHidrometroId;
    }
    
    public Long valueOfModeloHidrometroId() {
        return aModeloHidrometroId.getValue();
    }
    
    public boolean isModeloHidrometroIdModified() {
        return aModeloHidrometroId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_ENSAIO_BANCADA
        {
            EntHidrometroEnsaio hidrometroEnsaio = new EntHidrometroEnsaio(ctx);
            hidrometroEnsaio.del("select id from HIDROMETRO_ENSAIO where ENSAIO_BANCADA_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_ENSAIO_BANCADA
        {
            EntValorVariavelEnsaio valorVariavelEnsaio = new EntValorVariavelEnsaio(ctx);
            valorVariavelEnsaio.del("select id from VALOR_VARIAVEL_ENSAIO where ENSAIO_BANCADA_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.ENSAIO_BANCADA.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("FK_ENBANC_MODELO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_MODELO_HIDROMETRO", 
                        Severity.ERROR,
                        "Registro não cadastrado para MODELO_HIDROMETRO! (FK_ENBANC_MODELO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("FK_ENBANC_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_PLANO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PLANO_EXECUCAO! (FK_ENBANC_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("UK_ENBANC_SEQUENCIA") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.UK_ENBANC_SEQUENCIA", 
                        Severity.ERROR,
                        "Registro duplicado! A sequência automática deve ser única! Sequência automatica ${SEQUENCIA_AUTOMATICA} (UK_ENBANC_SEQUENCIA)");
                return e;
            } else if (msg.indexOf("OPERADOR_ENSAIO_DEVE_SER_COLABORADOR") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.OPERADOR_ENSAIO_DEVE_SER_COLABORADOR", 
                        Severity.ERROR,
                        "Regra inválida! Operador da ensaio deve ser um colaborador (a pessoa selecionada deve ser um usuário do sistema)! (OPERADOR_ENSAIO_DEVE_SER_COLABORADOR)");
                return e;
            } else if (msg.indexOf("FK_ENBANC_OPERADOR_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_OPERADOR_ENSAIO", 
                        Severity.ERROR,
                        "Registro não cadastrado para OPERADOR_ENSAIO! (FK_ENBANC_OPERADOR_ENSAIO)");
                return e;
            } else if (msg.indexOf("FK_ENBANC_BANCADA_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_BANCADA_ENSAIO", 
                        Severity.ERROR,
                        "Registro não cadastrado para BANCADA_ENSAIO! (FK_ENBANC_BANCADA_ENSAIO)");
                return e;
            } else if (msg.indexOf("FK_ENBANC_SOLICITACAO_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_SOLICITACAO_ENSAIO", 
                        Severity.ERROR,
                        "Registro não cadastrado para SOLICITACAO_ENSAIO! (FK_ENBANC_SOLICITACAO_ENSAIO)");
                return e;
            } else if (msg.indexOf("PK_ENBANC") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.PK_ENBANC", 
                        Severity.ERROR,
                        "ID duplicado! (PK_ENBANC)");
                return e;
            } else {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aSituacaoEnsaioHidrostatico);
            allAttributes.add(aSituacaoEnsaioVisual);
            allAttributes.add(aDataInicioEnsaio);
            allAttributes.add(aDataFimEnsaio);
            allAttributes.add(aHoraInicioEnsaio);
            allAttributes.add(aHoraFimEnsaio);
            allAttributes.add(aSolicitacaoEnsaioId);
            allAttributes.add(aBancadaEnsaioId);
            allAttributes.add(aQuantidadeHidrometros);
            allAttributes.add(aNumeroLaudo);
            allAttributes.add(aOperadorEnsaioId);
            allAttributes.add(aSituacao);
            allAttributes.add(aSequenciaAutomatica);
            allAttributes.add(aQuantidadeHidrometrosAprovados);
            allAttributes.add(aQuantidadeHidrometrosReprovados);
            allAttributes.add(aPlanoExecucaoId);
            allAttributes.add(aModeloHidrometroId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getSequenciaAutomatica().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findBySequenciaAutomatica(long sequenciaAutomatica) throws AdsException {
        findBy(new String[] {"SEQUENCIA_AUTOMATICA"},
                new Object[] {sequenciaAutomatica});
    }
    
    private EntModeloHidrometro eModeloHidrometro;
    
    public EntModeloHidrometro findModeloHidrometro() throws AdsException {
        if (getModeloHidrometroId().isNull()) {
            return null;
        }
        if (eModeloHidrometro == null || !valueOfModeloHidrometroId().equals(eModeloHidrometro.valueOfId())) {
            eModeloHidrometro = new EntModeloHidrometro(ctx);
            eModeloHidrometro.find(valueOfModeloHidrometroId());
        }
        return eModeloHidrometro;
    }
    
    /**
     * Ativa o join desta entidade com MODELO_HIDROMETRO
     * através do atributo MODELO_HIDROMETRO_ID
     */
    public EntModeloHidrometro joinModeloHidrometro() {
        return joinModeloHidrometro(null);
    }
    public EntModeloHidrometro joinModeloHidrometro(String alias) {
        EntModeloHidrometro entity = new EntModeloHidrometro(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getModeloHidrometroId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByModeloHidrometro(long id, String sqlAppend) throws AdsException {
        find("select ID from ENSAIO_BANCADA where MODELO_HIDROMETRO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByModeloHidrometro(long id) throws AdsException {
        findByModeloHidrometro(id,"");
    }
    
    public void findByModeloHidrometro(Entity entidade) throws AdsException {
        findByModeloHidrometro(entidade.valueOfId(),"");
    }
    
    public void findByModeloHidrometro(Entity entidade, String sqlAppend) throws AdsException {
        findByModeloHidrometro(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPlanoExecucao ePlanoExecucao;
    
    public EntPlanoExecucao findPlanoExecucao() throws AdsException {
        if (getPlanoExecucaoId().isNull()) {
            return null;
        }
        if (ePlanoExecucao == null || !valueOfPlanoExecucaoId().equals(ePlanoExecucao.valueOfId())) {
            ePlanoExecucao = new EntPlanoExecucao(ctx);
            ePlanoExecucao.find(valueOfPlanoExecucaoId());
        }
        return ePlanoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PLANO_EXECUCAO
     * através do atributo PLANO_EXECUCAO_ID
     */
    public EntPlanoExecucao joinPlanoExecucao() {
        return joinPlanoExecucao(null);
    }
    public EntPlanoExecucao joinPlanoExecucao(String alias) {
        EntPlanoExecucao entity = new EntPlanoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPlanoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPlanoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from ENSAIO_BANCADA where PLANO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPlanoExecucao(long id) throws AdsException {
        findByPlanoExecucao(id,"");
    }
    
    public void findByPlanoExecucao(Entity entidade) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPlanoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPessoa eOperadorEnsaio;
    
    public EntPessoa findOperadorEnsaio() throws AdsException {
        if (getOperadorEnsaioId().isNull()) {
            return null;
        }
        if (eOperadorEnsaio == null || !valueOfOperadorEnsaioId().equals(eOperadorEnsaio.valueOfId())) {
            eOperadorEnsaio = new EntPessoa(ctx);
            eOperadorEnsaio.find(valueOfOperadorEnsaioId());
        }
        return eOperadorEnsaio;
    }
    
    /**
     * Ativa o join desta entidade com PESSOA
     * através do atributo OPERADOR_ENSAIO_ID
     */
    public EntPessoa joinOperadorEnsaio() {
        return joinOperadorEnsaio(null);
    }
    public EntPessoa joinOperadorEnsaio(String alias) {
        EntPessoa entity = new EntPessoa(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getOperadorEnsaioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByOperadorEnsaio(long id, String sqlAppend) throws AdsException {
        find("select ID from ENSAIO_BANCADA where OPERADOR_ENSAIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByOperadorEnsaio(long id) throws AdsException {
        findByOperadorEnsaio(id,"");
    }
    
    public void findByOperadorEnsaio(Entity entidade) throws AdsException {
        findByOperadorEnsaio(entidade.valueOfId(),"");
    }
    
    public void findByOperadorEnsaio(Entity entidade, String sqlAppend) throws AdsException {
        findByOperadorEnsaio(entidade.valueOfId(),sqlAppend);
    }
    
    private EntInstrumentoEnsaio eBancadaEnsaio;
    
    public EntInstrumentoEnsaio findBancadaEnsaio() throws AdsException {
        if (getBancadaEnsaioId().isNull()) {
            return null;
        }
        if (eBancadaEnsaio == null || !valueOfBancadaEnsaioId().equals(eBancadaEnsaio.valueOfId())) {
            eBancadaEnsaio = new EntInstrumentoEnsaio(ctx);
            eBancadaEnsaio.find(valueOfBancadaEnsaioId());
        }
        return eBancadaEnsaio;
    }
    
    /**
     * Ativa o join desta entidade com INSTRUMENTO_ENSAIO
     * através do atributo BANCADA_ENSAIO_ID
     */
    public EntInstrumentoEnsaio joinBancadaEnsaio() {
        return joinBancadaEnsaio(null);
    }
    public EntInstrumentoEnsaio joinBancadaEnsaio(String alias) {
        EntInstrumentoEnsaio entity = new EntInstrumentoEnsaio(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getBancadaEnsaioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByBancadaEnsaio(long id, String sqlAppend) throws AdsException {
        find("select ID from ENSAIO_BANCADA where BANCADA_ENSAIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByBancadaEnsaio(long id) throws AdsException {
        findByBancadaEnsaio(id,"");
    }
    
    public void findByBancadaEnsaio(Entity entidade) throws AdsException {
        findByBancadaEnsaio(entidade.valueOfId(),"");
    }
    
    public void findByBancadaEnsaio(Entity entidade, String sqlAppend) throws AdsException {
        findByBancadaEnsaio(entidade.valueOfId(),sqlAppend);
    }
    
    private EntSolicitacaoEnsaio eSolicitacaoEnsaio;
    
    public EntSolicitacaoEnsaio findSolicitacaoEnsaio() throws AdsException {
        if (getSolicitacaoEnsaioId().isNull()) {
            return null;
        }
        if (eSolicitacaoEnsaio == null || !valueOfSolicitacaoEnsaioId().equals(eSolicitacaoEnsaio.valueOfId())) {
            eSolicitacaoEnsaio = new EntSolicitacaoEnsaio(ctx);
            eSolicitacaoEnsaio.find(valueOfSolicitacaoEnsaioId());
        }
        return eSolicitacaoEnsaio;
    }
    
    /**
     * Ativa o join desta entidade com SOLICITACAO_ENSAIO
     * através do atributo SOLICITACAO_ENSAIO_ID
     */
    public EntSolicitacaoEnsaio joinSolicitacaoEnsaio() {
        return joinSolicitacaoEnsaio(null);
    }
    public EntSolicitacaoEnsaio joinSolicitacaoEnsaio(String alias) {
        EntSolicitacaoEnsaio entity = new EntSolicitacaoEnsaio(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getSolicitacaoEnsaioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findBySolicitacaoEnsaio(long id, String sqlAppend) throws AdsException {
        find("select ID from ENSAIO_BANCADA where SOLICITACAO_ENSAIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findBySolicitacaoEnsaio(long id) throws AdsException {
        findBySolicitacaoEnsaio(id,"");
    }
    
    public void findBySolicitacaoEnsaio(Entity entidade) throws AdsException {
        findBySolicitacaoEnsaio(entidade.valueOfId(),"");
    }
    
    public void findBySolicitacaoEnsaio(Entity entidade, String sqlAppend) throws AdsException {
        findBySolicitacaoEnsaio(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eModeloHidrometro = null;
        ePlanoExecucao = null;
        eOperadorEnsaio = null;
        eBancadaEnsaio = null;
        eSolicitacaoEnsaio = null;
    }
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo ENSAIO_BANCADA_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioEnsaioBancada() throws AdsException {
        return findAllValorVariavelEnsaioEnsaioBancada("order by ID");
    }
    
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo ENSAIO_BANCADA_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioEnsaioBancada(String sqlAppend) throws AdsException {
        EntValorVariavelEnsaio out = new EntValorVariavelEnsaio(ctx);
        out.find("select ID from VALOR_VARIAVEL_ENSAIO where ENSAIO_BANCADA_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de HIDROMETRO_ENSAIO que referenciam este registro através do atributo ENSAIO_BANCADA_ID
     */
    public EntHidrometroEnsaio findAllHidrometroEnsaioEnsaioBancada() throws AdsException {
        return findAllHidrometroEnsaioEnsaioBancada("order by ID");
    }
    
    /**
     * Retorna os registros de HIDROMETRO_ENSAIO que referenciam este registro através do atributo ENSAIO_BANCADA_ID
     */
    public EntHidrometroEnsaio findAllHidrometroEnsaioEnsaioBancada(String sqlAppend) throws AdsException {
        EntHidrometroEnsaio out = new EntHidrometroEnsaio(ctx);
        out.find("select ID from HIDROMETRO_ENSAIO where ENSAIO_BANCADA_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oModeloHidrometroId.setValue(aModeloHidrometroId);
        oPlanoExecucaoId.setValue(aPlanoExecucaoId);
        oSituacao.setValue(aSituacao);
        oQuantidadeHidrometrosReprovados.setValue(aQuantidadeHidrometrosReprovados);
        oQuantidadeHidrometrosAprovados.setValue(aQuantidadeHidrometrosAprovados);
        oSequenciaAutomatica.setValue(aSequenciaAutomatica);
        oOperadorEnsaioId.setValue(aOperadorEnsaioId);
        oNumeroLaudo.setValue(aNumeroLaudo);
        oQuantidadeHidrometros.setValue(aQuantidadeHidrometros);
        oBancadaEnsaioId.setValue(aBancadaEnsaioId);
        oSolicitacaoEnsaioId.setValue(aSolicitacaoEnsaioId);
        oHoraFimEnsaio.setValue(aHoraFimEnsaio);
        oHoraInicioEnsaio.setValue(aHoraInicioEnsaio);
        oDataFimEnsaio.setValue(aDataFimEnsaio);
        oDataInicioEnsaio.setValue(aDataInicioEnsaio);
        oSituacaoEnsaioHidrostatico.setValue(aSituacaoEnsaioHidrostatico);
        oSituacaoEnsaioVisual.setValue(aSituacaoEnsaioVisual);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setName("PK_ENBANC");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setAssociatedEntity(EntInstrumentoEnsaio.class);
            rule.setName("FK_ENBANC_BANCADA_ENSAIO");
            rule.addAttribute(new DomId("BANCADA_ENSAIO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setAssociatedEntity(EntModeloHidrometro.class);
            rule.setName("FK_ENBANC_MODELO_HIDROMETRO");
            rule.addAttribute(new DomId("MODELO_HIDROMETRO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setAssociatedEntity(EntPessoa.class);
            rule.setName("FK_ENBANC_OPERADOR_ENSAIO");
            rule.addAttribute(new DomId("OPERADOR_ENSAIO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setAssociatedEntity(EntPlanoExecucao.class);
            rule.setName("FK_ENBANC_PLANO_EXECUCAO");
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setAssociatedEntity(EntSolicitacaoEnsaio.class);
            rule.setName("FK_ENBANC_SOLICITACAO_ENSAIO");
            rule.addAttribute(new DomId("SOLICITACAO_ENSAIO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setName("UK_ENBANC_SEQUENCIA");
            rule.addAttribute(new DomId("SEQUENCIA_AUTOMATICA",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setCheckAttribute(new DomOption("SITUACAO_ENSAIO_HIDROSTATICO",""));
            rule.setName("CKAV_20400073");
            rule.addAllowableValues(new String[] {"Z", "A", "R"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setCheckAttribute(new DomOption("SITUACAO_ENSAIO_VISUAL",""));
            rule.setName("CKAV_20400160");
            rule.addAllowableValues(new String[] {"Z", "A", "R"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntEnsaioBancada.class);
            rule.setCheckAttribute(new DomOption("SITUACAO",""));
            rule.setName("CKAV_20649306");
            rule.addAllowableValues(new String[] {"P", "E", "F", "C", "X"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        preencherPlanoExecucao(); //Preencher plano de execução
        preencherModeloEnsaioSolicitacao(); //Preencher modelo e ensaio da solicitação
        restringirAlteracaoModeloPlano(); //Restringir alteração do modelo e do plano de execução
        calcularSituacaoExecucaoEnsaio(); //Calcular situação da execução deste ensaio
        checkRule(isOperadorEnsaioDeveSerColaboradorValid(), "OPERADOR_ENSAIO_DEVE_SER_COLABORADOR", "Operador da ensaio deve ser um colaborador (a pessoa selecionada deve ser um usuário do sistema)!");
    }
    
    @Override
    protected void posInsert() throws AdsException {
        atualizarSituacaoQuantidadesSolicitacao(); //Atualizar situação e quantidades da solicitação
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        preencherModeloEnsaioSolicitacao(); //Preencher modelo e ensaio da solicitação
        restringirAlteracaoModeloPlano(); //Restringir alteração do modelo e do plano de execução
        calcularSituacaoExecucaoEnsaio(); //Calcular situação da execução deste ensaio
        checkRule(isOperadorEnsaioDeveSerColaboradorValid(), "OPERADOR_ENSAIO_DEVE_SER_COLABORADOR", "Operador da ensaio deve ser um colaborador (a pessoa selecionada deve ser um usuário do sistema)!");
    }
    
    @Override
    protected void posUpdate() throws AdsException {
        atualizarSituacaoQuantidadesSolicitacao(); //Atualizar situação e quantidades da solicitação
        criarProdutosAprovadasEnsaio(); //Criar produtos aprovadas neste ensaio
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aSequenciaAutomatica.isNull()) {
            aSequenciaAutomatica.setValue("" + ctx.getNextVal("seq_ensaios"));
        }
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getSituacao().isNull()) {
            setSituacao(getSituacao().getDefaultValue());
        }
        if (getQuantidadeHidrometrosReprovados().isNull()) {
            setQuantidadeHidrometrosReprovados(getQuantidadeHidrometrosReprovados().getDefaultValue());
        }
        if (getQuantidadeHidrometrosAprovados().isNull()) {
            setQuantidadeHidrometrosAprovados(getQuantidadeHidrometrosAprovados().getDefaultValue());
        }
        if (getSituacaoEnsaioHidrostatico().isNull()) {
            setSituacaoEnsaioHidrostatico(getSituacaoEnsaioHidrostatico().getDefaultValue());
        }
        if (getSituacaoEnsaioVisual().isNull()) {
            setSituacaoEnsaioVisual(getSituacaoEnsaioVisual().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Ajustar próximo número de série da solicitação.
     */
    private void ajustarProximoNumeroSerieSolicitacao() throws AdsException {
        // <user-code id="22045232" parentId="22045231" hashcode="-4a50a8f1" length="98">
        // TODO, incluir código para conferir e ajustar dados na entidade
        // "numero_serie_solicitacao"
        
        // </user-code>
    }
    
    /**
     * Criar produtos dos hidrômetros aprovados.
     */
    private void criarProdutosHidrometrosAprovados() throws AdsException {
        // <user-code id="20902579" parentId="20902570" hashcode="61725817" length="42">
        // TODO, implementar inclusão de produtos 
        // </user-code>
    }
    
    /**
     * Regra de validação: Operador da ensaio deve ser um colaborador (a pessoa selecionada deve ser um usuário do sistema)!
     */
    private Object isOperadorEnsaioDeveSerColaboradorValid() throws AdsException {
        // <user-code id="20626400" parentId="20626377" hashcode="-56f2d37a" length="66">
        return (findOperadorEnsaio().getUsuarioAssociadoId().isNotNull());
        // </user-code>
    }
    
    /**
     * Regra de ação: Atualizar situação e quantidades da solicitação
     */
    private void atualizarSituacaoQuantidadesSolicitacao() throws AdsException {
        // <user-code id="20902376" parentId="20902275" hashcode="6897658d" length="1368">
        if (getSolicitacaoEnsaioId().isNotNull()) {
            if (isSituacaoModified() && !valueOfSituacao().equals("P")) {
                EntSolicitacaoEnsaio solicitacao = findSolicitacaoEnsaio();
        
                if (valueOfSituacao().equals("F")) {
                    solicitacao.setQuantidadeHidrometrosAprovados(valueOfQuantidadeHidrometrosAprovados());
                    solicitacao.setQuantidadeHidrometrosReprovados(valueOfQuantidadeHidrometrosReprovados());
                    solicitacao.setQuantidadeHidrometrosPendentes(0);
                    solicitacao.setQuantidadeHidrometrosExecucao(0);
                } else if (valueOfSituacao().equals("E")) {
                    solicitacao.setQuantidadeHidrometrosAprovados(valueOfQuantidadeHidrometrosAprovados());
                    solicitacao.setQuantidadeHidrometrosReprovados(valueOfQuantidadeHidrometrosReprovados());
                    solicitacao.setQuantidadeHidrometrosPendentes(
                            valueOfQuantidadeHidrometros() - (valueOfQuantidadeHidrometrosAprovados() + valueOfQuantidadeHidrometrosReprovados())
                            );
                    solicitacao.setQuantidadeHidrometrosExecucao(valueOfQuantidadeHidrometros());
                }
                solicitacao.upd();
            } else if (isDataInicioEnsaioModified()) {
                if (valueOfSituacao().equals("P")) {
                    setSituacao("E");
                    atualizarSituacaoQuantidadesSolicitacao();
                }
            }
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Preencher plano de execução
     */
    private void preencherPlanoExecucao() throws AdsException {
        // <user-code id="21078861" parentId="21078848" hashcode="-7efa9cd4" length="128">
        if (getPlanoExecucaoId().isNull()) {
            setPlanoExecucaoId(findSolicitacaoEnsaio().valueOfPlanoExecucaoId().longValue());
        }
        
        // </user-code>
    }
    
    /**
     * Regra de ação: Preencher modelo e ensaio da solicitação
     */
    private void preencherModeloEnsaioSolicitacao() throws AdsException {
        // <user-code id="22035166" parentId="22035068" hashcode="26e6284a" length="139">
        if (getSolicitacaoEnsaioId().isNotNull()) {
            setModeloHidrometroId(findSolicitacaoEnsaio().valueOfModeloHidrometroId().longValue());
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Restringir alteração do modelo e do plano de execução
     */
    private void restringirAlteracaoModeloPlano() throws AdsException {
        // <user-code id="22035215" parentId="22035208" hashcode="-77252d41" length="924">
        if (isModeloHidrometroIdModified() || isPlanoExecucaoIdModified()) {
            boolean erro = false;
            if (currentTransaction == INSERT_TRANSACTION) {
                if (getSolicitacaoEnsaioId().isNotNull()) {
                    if (valueOfModeloHidrometroId().longValue() != findSolicitacaoEnsaio().valueOfModeloHidrometroId().longValue() ||
                        valueOfPlanoExecucaoId().longValue() != findSolicitacaoEnsaio().valueOfPlanoExecucaoId().longValue())
                    {   
                        erro = true;
                    }
                }
            } else if (currentTransaction == UPDATE_TRANSACTION) {
                if (getSolicitacaoEnsaioId().isNotNull()) {
                    erro = true;
                }
            }
            if (erro) {
                throw new AdsException(ENTITY_NAME,
                        Severity.ERROR,
                        "Alteração não permitida! Modelo do hidrômetro e plano devem ser iguais aos da solicitação de ensaio registrada.");
            }        
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular situação da execução deste ensaio
     */
    private void calcularSituacaoExecucaoEnsaio() throws AdsException {
        // <user-code id="20902512" parentId="20902477" hashcode="35695339" length="399">
        if (isQuantidadeHidrometrosAprovadosModified() || isQuantidadeHidrometrosReprovadosModified()) {
            if (valueOfQuantidadeHidrometros() == (valueOfQuantidadeHidrometrosAprovados() + valueOfQuantidadeHidrometrosReprovados())) {
                setSituacao("F");
            } else if ((valueOfQuantidadeHidrometrosAprovados() + valueOfQuantidadeHidrometrosReprovados()) > 0) {
                setSituacao("E");
            }
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Criar produtos aprovadas neste ensaio
     */
    private void criarProdutosAprovadasEnsaio() throws AdsException {
        // <user-code id="22045323" parentId="22045274" hashcode="-7a2f63a7" length="291">
        /*
        if (isSituacaoModified() &&
                (!oSituacao.getValue().equals(valueOfSituacao()) &&
                valueOfSituacao().equals("F"))
        {        
            AJUSTAR_PROXIMO_NUMERO_SERIE_SOLICITACAO();
            if (ctx.hasErrors()) {
                CRIAR_PRODUTOS_HIDROMETROS_APROVADOS();
            }
        }        
        */
        // </user-code>
    }
}
